Git Commands Cheat Sheet - WittyWriter

Git Commands Cheat Sheet

📘 Key Concepts and Definitions

Repository (Repo): A directory containing your project's files and the entire history of changes.
Working Directory: The local folder of files that you are currently working on.
Staging Area (Index): A file that stores information about what will go into your next commit. It's a preview of your next commit.
Commit: A snapshot of your repository at a specific point in time. Commits are the basic units of the Git timeline.
Branch: A lightweight, movable pointer to a commit. It represents an independent line of development. The default is usually main or master.
HEAD: A pointer that refers to the currently checked-out commit, typically the tip of the current branch.
Remote: A version of your repository hosted on a network (like GitHub or GitLab).
Merge: The process of combining the history of two or more branches into a single branch.
Rebase: The process of moving or combining a sequence of commits to a new base commit. It rewrites project history.

🧮 Command Syntax Patterns

Git commands follow a standard structure, which helps in understanding how to use them.

git <command> [<subcommand>] [-options] [<arguments>]

<command>: The main action you want to perform (e.g., commit, branch, push).
[<subcommand>]: An optional secondary action (e.g., git remote add).
[-options]: Modifiers for the command, also called flags (e.g., git commit -m "message"). Short form is one dash (-m), long form is two dashes (--message).
[<arguments>]: The target of the command, often a file path or a branch name (e.g., git add index.html).

🛠️ Tools, Commands, or Syntax

Configuration & Setup

Configure user info: git config --global user.name "[name]" and git config --global user.email "[email]"
Initialize a new local repository: git init
Clone an existing repository: git clone [url]

Making Changes (Local)

Check status of working directory: git status
Add a file to the staging area: git add [file]
Add all changed files to staging: git add .
View changes before staging: git diff
View staged changes: git diff --staged
Commit staged changes: git commit -m "[descriptive message]"
Unstage a file: git restore --staged [file]
Discard changes in a file: git restore [file]

Branching & Merging

List all branches: git branch
Create a new branch: git branch [branch-name]
Switch to a branch: git checkout [branch-name]
Create and switch to a new branch: git checkout -b [branch-name]
Merge a branch into the current branch: git merge [branch-name]
Reapply commits from current branch onto another: git rebase [base-branch-name]
Delete a local branch: git branch -d [branch-name] (-D to force)

Working with Remotes

List remote repositories: git remote -v
Add a remote repository: git remote add [name] [url] (e.g., origin)
Fetch changes from a remote: git fetch [remote-name]
Fetch and merge changes from remote: git pull [remote-name] [branch-name]
Push local branch to remote: git push [remote-name] [branch-name]
Push a new branch to remote and track it: git push -u [remote-name] [branch-name]

🧭 Step-by-Step Guides or Workflows

Basic Feature Branch Workflow

Update your local main branch:
```
git checkout main
git pull origin main
```
Create a new branch for your feature:
```
git checkout -b new-feature-branch
```
Make your changes: Edit, create, and delete files.

Stage and commit your changes:

git add .
git commit -m "Add new feature X"

Push your branch to the remote repository:
```
git push -u origin new-feature-branch
```
Open a Pull Request (PR) on the repository's web interface (e.g., GitHub).
Once the PR is approved and merged, you can safely delete your local branch:
```
git checkout main
git branch -d new-feature-branch
```

Best Practice: Always work on feature branches, not directly on the main branch. This keeps the main line of development clean and stable.

⌨️ Shortcuts and Productivity Tips

Git Aliases

Create shortcuts for long commands in your .gitconfig file.

git config --global alias.co checkout (Now use git co)
git config --global alias.br branch (Now use git br)
git config --global alias.ci commit (Now use git ci)
git config --global alias.st status (Now use git st)

Advanced Log: A very popular alias for a prettier log view.

git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"

Time-Saving Tricks

Commit and stage at once: git commit -am "message" adds all tracked files and commits.
Switch to the previous branch: git checkout -
Interactively add changes: git add -p lets you review and stage parts of a file.

📊 Tables, Charts, or Visual Aids

Flow of a File in Git


 Working Directory     --->    Staging Area     --->    Local Repository
 (Untracked files)     |         (Index)          |       (.git directory)
                       |                          |
   (modified file) --git add--> (staged file) --git commit--> (versioned file)

Merge vs. Rebase

Aspect	`git merge`	`git rebase`
History	Preserves history as it happened. Creates a "merge commit".	Rewrites history to create a linear, cleaner timeline.
Collaboration	Safer for public/shared branches as it doesn't change existing commits.	Can be dangerous on shared branches. Best used on private feature branches.
Complexity	Simpler to use and understand.	More powerful, but can be more complex to resolve conflicts.

🧪 Examples and Use Cases

Problem: I committed something, but forgot to add a file.

You don't need a new commit. You can amend the previous one.

Add the file you forgot: git add [forgotten-file]
Amend the previous commit: git commit --amend --no-edit

The --no-edit flag keeps the original commit message. Omit it to write a new one. Be careful amending commits that have already been pushed.

Problem: I need to sync my forked repository with the original.

Add the original repository as a remote (you only do this once):
git remote add upstream [original-repo-url]
Fetch changes from the original repository:
git fetch upstream
Checkout your main branch and merge the changes:
git checkout main
git merge upstream/main

🧹 Troubleshooting and Debugging

"I need to undo my last commit (local only)":
- To undo the commit but keep the changes: git reset --soft HEAD~1
- To undo the commit AND unstage the changes: git reset HEAD~1
- To permanently discard the commit AND all changes: git reset --hard HEAD~1 (Use with caution!)
"I accidentally committed to the wrong branch":
1. Checkout the correct branch: git checkout correct-branch
2. Bring the commit over: git cherry-pick [commit-hash-from-wrong-branch]
3. Go back to the wrong branch: git checkout wrong-branch
4. Remove the mistaken commit: git reset --hard HEAD~1
"I need to find a lost commit":
- git reflog shows a log of all actions where HEAD was changed. Find the commit hash in the reflog and you can check it out or cherry-pick it back.

Warning: Be very careful with commands that rewrite history (like git reset --hard and git rebase) on branches that are shared with other people.

📚 References and Further Reading

Official Documentation: Git Official Documentation
The "Pro Git" Book: Pro Git (A fantastic, free online book)
Interactive Tutorial: Learn Git Branching
Quick Reference: GitHub Training Cheat Sheets
Community Forums: Stack Overflow's Git Tag